home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GEM / GRAFBASE.D < prev    next >
Encoding:
Modula Definition  |  1990-10-09  |  15.3 KB  |  382 lines
  1. DEFINITION MODULE GrafBase;
  2.  
  3.  
  4. (*  Definition der grundlegenden Typen für die Grafikbibliotheken des
  5.  *  Megamax Modula-2 Entwicklungspackets. Außerdem Routinen zur Ver-
  6.  *  arbeitung dieser Strukturen.
  7.  *
  8.  *  Autor: Manuel Chakravarty           Erstellt: 28.10.87
  9.  *
  10.  *  Version   2.1     V#0016
  11.  *)
  12.  
  13.  
  14. (*  Dieses Modul enthält grundlegende Grafikstrukturen, die sowohl von
  15.  *  dem Modul 'LineA', als auch von den GEM-Moduln benutzt werden.
  16.  *)
  17.  
  18.  
  19. FROM SYSTEM IMPORT WORD, ADDRESS;
  20.  
  21.  
  22. CONST           (* Standard Farbenpalette *)
  23.  
  24.         white           = 0;
  25.         black           = 1;
  26.         red             = 2;
  27.         green           = 3;
  28.         blue            = 4;
  29.         cyan            = 5;
  30.         yellow          = 6;
  31.         magenta         = 7;
  32.         lwhite          = 8;
  33.         lblack          = 9;
  34.         lred            = 10;
  35.         lgreen          = 11;
  36.         lblue           = 12;
  37.         lcyan           = 13;
  38.         lyellow         = 14;
  39.         lmagenta        = 15;
  40.         
  41.         
  42. TYPE    WritingMode     = (replaceWrt, transWrt, xorWrt, reverseWrt);
  43.         
  44.         (*  Es bedeutet dabei:
  45.          *
  46.          *  'replaceWrt' -- Die Zeichnung verdeckt den Hintergrund.
  47.          *                  (Wird meistens benutzt)
  48.          *  'transWrt'   -- Die Zeichnung ist durchsichtigt,
  49.          *                  d.h ist in der Zeichenmaske ein Punkt
  50.          *                  nicht besetzt, so scheint der aktuelle
  51.          *                  Hintergrund durch.
  52.          *                  (entspricht einer ODER-Verknüpfung)
  53.          *  'eorWrt'     -- Die Zeichnung wird mit dem Hintergrund ex-
  54.          *                  clusiv-oder verknüpft. Dieser Modus hat
  55.          *                  unter anderem zur Folge, daß zweimaliges
  56.          *                  Zeichnen derselben Zeichnung den Hinter-
  57.          *                  grund wieder restauriert.
  58.          *  'reverseWrt' -- Auch hier ist die Zeichnung durchsichtigt,
  59.          *                  aber diesmal scheint der Hintergrund an den
  60.          *                  Punkten durch, die in der Zeichenmaske ge-
  61.          *                  setzt sind
  62.          *)
  63.          
  64.          
  65.         BitOperation    = (allZero, sAndD, sAndNotD, onlyS,
  66.                            notSAndD, onlyD, sXorD, sOrD,
  67.                            not0SOrD, not0SXorD, notD, sOrNotD,
  68.                            notS, notSOrD, not0SAndD, allOne);
  69.         
  70.         (*  Die Operationen sind folgendermaßen definiert:
  71.          *
  72.          *   allZero   --  Zn = 0           (Ziel wird vollständig gelöscht)
  73.          *   sAndD     --  Zn = Q & Z
  74.          *   sAndNotD  --  Zn = Q & ~Z
  75.          *   onlyS     --  Zn = Q           (Zielbereich wird einfach ersetzt)
  76.          *   notSAndD  --  Zn = ~Q & Z      (Quelle löscht Zielbereich)
  77.          *   onlyD     --  Zn = Z           (Ziel bleibt erhalten)
  78.          *   sXorD     --  Zn = Q xor Z     (Exclusiv-Oder Verknüpfung)
  79.          *   sOrD      --  Zn = Q | Z       (Transparent)
  80.          *   not0SOrD  --  Zn = ~(Q | Z)    (Transparent und invertiert)
  81.          *   not0SXorD --  Zn = ~(Q xor Z)
  82.          *   notD      --  Zn = ~Z
  83.          *   sOrNotD   --  Zn = Q | ~Z
  84.          *   notS      --  Zn = ~Q          (Kopiert invertierten Quellbereich)
  85.          *   notSOrD   --  Zn = ~Q | Z
  86.          *   not0SAndD --  Zn = ~(Q & Z)
  87.          *   allOne    --  Zn = 1           (Ziel wird vollständig gesetzt)
  88.          *
  89.          *  Dabei ist:
  90.          *              'Q'   -- Bits im Quellbereich
  91.          *              'Z'   -- Bits im Zielbereich (vor der Verknüpfung)
  92.          *              'Zn'  -- Bits im Zielbereich (nach dem Verknüpfung)
  93.          *              '&'   -- Logisches UND
  94.          *              '|'   -- Logisches ODER
  95.          *              '~'   -- Logisches NICHT
  96.          *              'xor' -- Logisches EXCLUSIV-ODER
  97.          *
  98.          *  Anmerkung: Diese Verknüpfungen repräsentieren jede zweistellige
  99.          *             Operation auf Bits (2^4 = 16 Möglichkeiten).
  100.          *)
  101.          
  102.          
  103.         Point           = RECORD
  104.                             x: INTEGER;
  105.                             y: INTEGER;
  106.                           END;
  107.         
  108.         LongPnt         = RECORD
  109.                             x: LONGINT;
  110.                             y: LONGINT;
  111.                           END;
  112.                          
  113.         Rectangle       = RECORD
  114.                             x: INTEGER;
  115.                             y: INTEGER;
  116.                             w: INTEGER;
  117.                             h: INTEGER;
  118.                           END;
  119.                                  
  120.         LongRect        = RECORD
  121.                             x: LONGINT;
  122.                             y: LONGINT;
  123.                             w: LONGINT;
  124.                             h: LONGINT;
  125.                           END;
  126.                                  
  127. PROCEDURE Pnt (x, y: INTEGER): Point;
  128. PROCEDURE LPnt (x, y: LONGINT): LongPnt;
  129.  
  130.         (*  Liefert ein Record, welches den Punkt mit den Koordinaten 'x'
  131.          *  und 'y' beschreibt.
  132.          *)
  133.  
  134. PROCEDURE Rect (x, y, w, h: INTEGER): Rectangle;
  135. PROCEDURE LRect (x, y, w, h: LONGINT): LongRect;
  136.  
  137.         (*  Erzeugt ein Record, das ein Rechteck beschreibt, dessen linker,
  138.          *  oberer Punkt die Koordinaten 'x' und 'y' besitzt und das 'w'
  139.          *  Pixel breit und 'h' Pixel hoch ist.
  140.          *)
  141.  
  142. PROCEDURE ShortPoint (p    : LongPnt  ): Point;
  143. PROCEDURE LongPoint  (p    : Point    ): LongPnt;
  144. PROCEDURE ShortFrame (frame: LongRect ): Rectangle;
  145. PROCEDURE LongFrame  (frame: Rectangle): LongRect;
  146.  
  147.         (*  Typwandlungen
  148.          *)
  149.  
  150. PROCEDURE AbsZoomRect (frame: Rectangle; xDelta, yDelta: INTEGER): Rectangle;
  151.  
  152.         (*  'frame' wird zentrisch gestreckt und zwar in x-Richtung um
  153.          *  'xDelta' Pixel und in y-Richtung um 'yDelta' Pixel.
  154.          *  Negative Deltawerte verkleinern die Ausmaße des Rechtecks,
  155.          *  und führen für Werte kleiner '-frame.w' bzw. '-frame.h'
  156.          *  zu einer Spiegelung des Rechtecks an einer Parallelen der
  157.          *  x-Achse bzw. y-Achse, die durch den Mittelpunkt des Recht-
  158.          *  eckes geht. Sind beide Werte kleiner, so entspricht dies
  159.          *  einer Punktspiegelung am Rechtecksmittelpunkt.
  160.          *)
  161.  
  162. PROCEDURE RelZoomRect (frame: Rectangle; xFactor, yFactor: LONGINT): Rectangle;
  163.  
  164.         (*  Auch hier wird das Rechteck 'frame' zentrisch gestreckt, nur
  165.          *  werden diesmal relative Maßzahlen für die Streckung benutzt.
  166.          *  Die Ausmaße des Rechtecks werden mit '...Factor DIV 1000'
  167.          *  multipliziert. Das bedeutet, daß ein Faktor von 1000 das
  168.          *  Rechteck unverändert läßt, negative Faktoren eine Spiegelung,
  169.          *  Faktoren zwischen -999 und 999 eine Verkleinerung und Fak-
  170.          *  toren deren Betrag größer 1000 ist eine Vergrößerung nach
  171.          *  sich ziehen.
  172.          *)
  173.  
  174. PROCEDURE TransRect (frame: Rectangle; p: Point): Rectangle;
  175. PROCEDURE LTransRect (frame: LongRect; p: LongPnt): LongRect;
  176.  
  177.         (*  Liefert 'Rect (p.x, p.y, frame.w, frame.h)' entspricht also
  178.          *  einer Translation des Rechtecks 'frame' zum Punkt 'p'.
  179.          *)
  180.  
  181. PROCEDURE MinPoint (frame: Rectangle): Point;
  182. PROCEDURE LMinPoint (frame: LongRect): LongPnt;
  183.  
  184.         (*  Liefert 'Pnt(frame.x,frame.y)'
  185.          *)
  186.  
  187. PROCEDURE MaxPoint (frame: Rectangle): Point;
  188. PROCEDURE LMaxPoint (frame: LongRect): LongPnt;
  189.  
  190.         (*  Liefert 'Pnt(frame.x+frame.w-1,frame.y+frame.h-1)'
  191.          *)
  192.  
  193. PROCEDURE ClipRect (frame: Rectangle; clip: Rectangle): Rectangle;
  194. PROCEDURE LClipRect (frame: LongRect; clip: LongRect): LongRect;
  195.  
  196.         (*  Diese Routine "clippt" das Rechteck 'frame' auf den Bereich
  197.          *  'clip', d.h. es wird der Ausschnitt von 'frame' berechnet,
  198.          *  der innerhalb von 'clip' liegt.
  199.          *)
  200.  
  201. PROCEDURE FrameRects (frame1, frame2: Rectangle): Rectangle;
  202. PROCEDURE LFrameRects (frame1, frame2: LongRect): LongRect;
  203.  
  204.         (*  Liefert das kleinste Rechteck, das 'frame1' und 'frame2'
  205.          *  vollständig einschließt.
  206.          *)
  207.  
  208. PROCEDURE FramePoints (p1, p2: Point): Rectangle;
  209. PROCEDURE LFramePoints (p1, p2: LongPnt): LongRect;
  210.  
  211.         (*  Liefert das Rechteck, das von 'p1' und 'p2' aufgespannt wird.
  212.          *)
  213.  
  214.  
  215. TYPE
  216.         (*  Bit0(b0) bis Bit15(b15) sind in der Reihenfolge aufgeführt,
  217.          *  in der sie auch im Speicher abgelegt werden.
  218.          *
  219.          *  ACHTUNG: Ab Version 2.1 ist dies nun eine neue Reihenfolge.
  220.          *           Für Compilerversionen 4.0 aufwärts.
  221.          *)
  222.         
  223.         BitsPerWord             = (b0,b1,b2 ,b3 ,b4 ,b5 ,b6 ,b7,
  224.                                    b8,b9,b10,b11,b12,b13,b14,b15);
  225.         WordBitSet              = SET OF BitsPerWord;
  226.         
  227.         PtrBitPattern           = POINTER TO ARRAY [0..MaxCard] OF WordBitSet;
  228.         
  229.         BitBlk16x16             = ARRAY [0..15] OF WordBitSet;
  230.         PtrBitBlk16x16          = POINTER TO BitBlk16x16;
  231.  
  232.  
  233.         MouseFormDef            = RECORD
  234.                                     hotSpot     : Point;
  235.                                     noPlanes    : CARDINAL;
  236.                                     maskColor   : CARDINAL;
  237.                                     dataColor   : CARDINAL;
  238.                                     mask        : BitBlk16x16;
  239.                                     data        : BitBlk16x16;
  240.                                   END;
  241.         PtrMouseFormDef         = POINTER TO MouseFormDef;
  242.         
  243.         (*  Es bedeutet:
  244.          *
  245.          *  'hotSpot'   -- Gibt den Punkt innerhalb der Mausform an, der
  246.          *                 beim Erfragen der Mauszeigerposition als Er-
  247.          *                 gebniss geliefert wird.
  248.          *  'noPlanes'  -- Anzahl der Bitebenene (muß gleich 1 sein)
  249.          *  'maskColor' -- Farbindex der Maskenbits
  250.          *  'dataColor' -- Farbindex der Datenbits
  251.          *  'mask'      -- 16x16 bit Muster der Maske
  252.          *  'data'      -- Bitmuster der Datenbits
  253.          *)
  254.                                     
  255.         MemFormDef              = RECORD
  256.                                     start        : ADDRESS;
  257.                                     w            : CARDINAL;
  258.                                     h            : CARDINAL;
  259.                                     words        : CARDINAL;
  260.                                     standardForm : BOOLEAN;
  261.                                     planes       : CARDINAL;
  262.                                     res1         : WORD;
  263.                                     res2         : WORD;
  264.                                     res3         : WORD;
  265.                                   END;
  266.         PtrMemFormDef           = POINTER TO MemFormDef;
  267.         
  268.         (*
  269.          *
  270.          *  Dabei bedeuten:
  271.          *
  272.          *          'start'        -- Startaddresse des Speicherbereichs
  273.          *          'w'            -- Breite des Rasters (in Pixel)
  274.          *          'h'            -- Höhe des Rasters (in Pixel)
  275.          *          'words'        -- Breite des Rasters (in 16-Bit-Worten)
  276.          *          'standardForm' -- TRUE  ~ Standard Format
  277.          *                            FALSE ~ Gerätespezifisches Format
  278.          *          'planes'       -- Anzahl der Bitebenen
  279.          *          'res1 - 3'     -- Reserviert für zukünftige Anwendungen
  280.          *
  281.          *  Setzt man die Startaddresse gleich Null, so wird keiner der
  282.          *  folgenden Parameter berücksichtigt und statt dessen das ange-
  283.          *  gebene physikalische Gerät (wird durch Geräte-Handle identi-
  284.          *  fiziert) benutzt (z.B. Bildschirm). In diesem Fall wird auch,
  285.          *  falls es gesetzt ist, das Clipping-Rechteck berücksichtigt
  286.          *  (siehe 'VDIControls').
  287.          *  Wird eine Startaddresse ungleich Null angegeben, so ist der
  288.          *  Platzbedarf des beschriebene Blocks 'words * h * 2' Byte.
  289.          *  Außerdem gilt 'w = words * h'.
  290.          *
  291.          *)
  292.                          
  293.                          
  294. PROCEDURE GetPhysMemForm (VAR memForm: MemFormDef);
  295.  
  296.         (*  Berechnet den Memory Form Definition Block für den aktuellen
  297.          *  physikalischen Bildschirm (mit aktueller Auflösung).
  298.          *
  299.          *  ACHTUNG: Da diese Routine auf den Line-A-Variablen aufbaut
  300.          *           und teilweise auch die negativen Line-A-Variablen
  301.          *           nutzt, sollte sie in Programmen, die mit der Ziel-
  302.          *           setzung erstellt werden auch auf Weiterentwicklungen
  303.          *           des Atari ST zu funktionieren nicht verwendet werden.
  304.          *           Eine Alternative bietet 'GEMEnv.DeviceParameter',
  305.          *           die das VDI nutzt.
  306.          *)
  307.  
  308. PROCEDURE GetLogMemForm (VAR memForm: MemFormDef);
  309.  
  310.         (*  Entspricht 'GetPhysMemForm' für den logischen Bildschirm.
  311.          *)
  312.         
  313.  
  314. (*  Die folgenden Routinen erfragen ihre Daten durch XBIOS-Aufrufe.
  315.  *)
  316.  
  317. PROCEDURE GetBlitterMode (VAR available, active: BOOLEAN);
  318.  
  319.         (*  Erfragt den Zustand des Blitters.
  320.          *
  321.          *  'available' gibt an ob der Blitter im Rechner eingebaut ist,
  322.          *  und 'active' meldet, ob der Blitter benuzt wird oder nicht.
  323.          *)
  324.  
  325. PROCEDURE SetBlitterMode (active: BOOLEAN);
  326.  
  327.         (*  Falls ein Bit-Block Transfer Processor eingebaut ist, so
  328.          *  kann mit dieser Routine bestimmt werden, ob er benutzt
  329.          *  werden soll oder nicht.
  330.          *)
  331.  
  332. PROCEDURE GetScreen (VAR log, phys:ADDRESS; VAR rez: INTEGER);
  333.  
  334.         (*  Liefert die Addresse des aktuellen logischen Bildschirms
  335.          *  (das ist der Bildschirm auf den alle Ausgaben gemacht
  336.          *  werden) und des physikalischen Bildschirms (dies ist der
  337.          *  sichtbare Bildschirm) und die momentane Auflösung, dabei
  338.          *  gilt: 2 ~ HiRes | 1 ~ MidRes | 0 ~ LowRes .
  339.          *
  340.          *  HINWEIS: Die in 'rez' gelieferte Bildschirmauflösung
  341.          *           beachtet Sonderauflösungen, wie Großbildschirme
  342.          *           oder ähnliches natürlich nicht.
  343.          *)
  344.  
  345. PROCEDURE SetScreen (log, phys: ADDRESS; rez: INTEGER);
  346.  
  347.         (*  Mit 'SetScreen' lassen sich die mit 'GetScreen' erfragten
  348.          *  Parameter neu setzen. Soll einer der Werte unverändert
  349.          *  bleiben, so muß für ihn -1L bzw. -1 übergeben werden.
  350.          *)
  351.          
  352.  
  353. TYPE    Palette         = ARRAY [0..15] OF CARDINAL;
  354.         PtrPalette      = POINTER TO Palette;
  355.         
  356.         (*  Ein Paletteneintrag ist folgendermaßen aufgebaut:
  357.          *
  358.          *  0000 0rrr 0ggg 0bbb ,  dabei steht jedes Zeichen für ein Bit
  359.          *                         rrr gibt den Rotanteil, ggg den Grün-
  360.          *                         anteil und bbb den Blauanteil der be-
  361.          *                         schriebenen Farbe an.
  362.          *)
  363.          
  364. PROCEDURE SetPalette (newPalette: PtrPalette);
  365.  
  366.         (*  Setzt eine neue Farbpalette. Die neue Palette wird beim
  367.          *  nächsten VBL-Interrupt gesetzt.
  368.          *)
  369.          
  370. PROCEDURE SetColor (colorNum, color: CARDINAL);
  371.  
  372.         (*  Damit wird die Farbe 'colorNum' auf den Farbwert 'color' gesetzt.
  373.          *  Der Aufbau des Farbwertes entspricht einem Eintrag in 'Palette'.
  374.          *)
  375.  
  376. PROCEDURE ColorNumber (colorNum: CARDINAL): CARDINAL;
  377.  
  378.         (*  Ließt den mit 'SetColor' gesetzten Wert.
  379.          *)
  380.  
  381. END GrafBase.
  382.